package com.ruoyi.system.service.impl;

import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.core.utils.bean.BeanUtils;
import com.ruoyi.common.core.utils.bean.BeanValidators;
import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.api.domain.SysUser;
import com.ruoyi.system.domain.CapitalAccount;
import com.ruoyi.system.domain.vo.CapitalAccountVO;
import com.ruoyi.system.mapper.CapitalAccountMapper;
import com.ruoyi.system.service.CapitalAccountService;
import org.apache.ibatis.session.SqlSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

/**
 * @author : 王孟轩
 * @date : 2025/2/24 22:14
 * @description : 资金账户服务实现类
 **/
@Service
@Transactional
public class CapitalAccountServiceImpl implements CapitalAccountService {

    private static final Logger log = LoggerFactory.getLogger(CapitalAccountServiceImpl.class);

    @Autowired
    CapitalAccountMapper capitalAccountMapper;

    /**
     * 添加资金账户
     * @param capitalAccountVO 资金账户视图对象
     * @return AjaxResult 添加结果
     */
    @Override
    public AjaxResult CapitalAccountAdd(CapitalAccountVO capitalAccountVO) {
        // 根据资金账户编码或名称查询已存在的记录
        ArrayList<CapitalAccount> codeOrName = capitalAccountMapper.getRecordByCodeOrName(
                capitalAccountVO.getAccountCoding(), capitalAccountVO.getAccountTitle(),capitalAccountVO.getAccountSort());
        System.out.println("codeOrName中的数据"+codeOrName);
        // 检查是否存在重复的编码或名称
        if (codeOrName.size() > 0) {
            Optional<CapitalAccount> first = codeOrName.stream().filter(capitalAccount ->
                            capitalAccount.getAccountCoding().equals(capitalAccountVO.getAccountCoding()) ||
                                    capitalAccount.getAccountTitle().equals(capitalAccountVO.getAccountTitle()))
                    .findFirst();
            if (first.isPresent()) {
                CapitalAccount capitalAccount = first.get();
                if (capitalAccount.getAccountCoding().equals(capitalAccountVO.getAccountCoding())) {
                    return AjaxResult.error("资金账户编码重复");
                }
                if (capitalAccount.getAccountTitle().equals(capitalAccountVO.getAccountTitle())) {
                    return AjaxResult.error("资金账户名称重复");
                }
            }
        }

        // 验证资金账户编码是否为空
        if (capitalAccountVO.getAccountCoding() == null) {
            return AjaxResult.error("请输入资金账户编码");
        }
        // 验证资金账户名称是否为空
        if (capitalAccountVO.getAccountTitle() == null) {
            return AjaxResult.error("请输入资金账户名称");
        }
        // 验证资金账户币种是否为空
        if (capitalAccountVO.getCurrencyId() == null) {
            return AjaxResult.error("请输入资金账户币种");
        }
        // 验证资金账户科目是否为空
        if (capitalAccountVO.getSubjectId() == null) {
            return AjaxResult.error("请输入资金账户科目");
        }
        // 如果账户类型为1，验证银行和银行卡号
        if (capitalAccountVO.getAccountSort() == 1) {
            if (capitalAccountVO.getBankId() == null) {
                return AjaxResult.error("请输入资金账户银行");
            }
            if (capitalAccountVO.getCardNumber() == 0) {
                return AjaxResult.error("请输入资金账户银行卡号");
            }
        }

        // 将 CapitalAccountVO 转换为 CapitalAccount
        CapitalAccount capitalAccount = new CapitalAccount();
        BeanUtils.copyBeanProp(capitalAccount, capitalAccountVO);
        // 执行添加操作
        int i = capitalAccountMapper.CapitalAccountAdd(capitalAccount);
        if (i > 0) {
            return AjaxResult.success("添加成功");
        }
        return AjaxResult.error("添加失败");
    }

    /**
     * 查询资金账户列表
     * @param capitalAccountVO 资金账户视图对象
     * @return AjaxResult 查询结果
     */
    @Override
    public AjaxResult CapitalAccountList(CapitalAccountVO capitalAccountVO) {
        // 参数校验
        if (capitalAccountVO == null) {
            return AjaxResult.warn("查询条件不能为空");
        }

        // 将 CapitalAccountVO 转换为 CapitalAccount
        CapitalAccount capitalAccount = new CapitalAccount();
        BeanUtils.copyBeanProp(capitalAccount, capitalAccountVO);

        try {
            // 执行查询操作
            ArrayList<CapitalAccount> capitalAccounts = capitalAccountMapper.CapitalAccountList(capitalAccount);

            // 记录日志
            log.info("查询资金账户，条件: {}, 查询结果: {} 条记录", capitalAccountVO, capitalAccounts.size());

            // 返回查询结果
            return AjaxResult.success("查询成功", capitalAccounts);
        } catch (Exception e) {
            // 记录异常日志
            log.error("查询资金账户时发生异常，条件: {}", capitalAccountVO, e);
            return AjaxResult.error("查询失败，系统异常：" + e.getMessage());
        }
    }

    /**
     * 更新资金账户
     * @param capitalAccountVO 资金账户视图对象
     * @return AjaxResult 更新结果
     */
    @Override
    public AjaxResult CapitalAccountUpdate(CapitalAccountVO capitalAccountVO) {
        // 参数校验
        if (capitalAccountVO == null) {
            return AjaxResult.warn("资金账户信息不能为空");
        }

        if (capitalAccountVO.getAccountCoding() == null || capitalAccountVO.getAccountCoding().trim().isEmpty()) {
            return AjaxResult.warn("请输入资金账户编码");
        }

        if (capitalAccountVO.getAccountTitle() == null || capitalAccountVO.getAccountTitle().trim().isEmpty()) {
            return AjaxResult.warn("请输入资金账户名称");
        }

        if (capitalAccountVO.getCurrencyId() == null) {
            return AjaxResult.warn("请输入资金账户币种");
        }

        if (capitalAccountVO.getSubjectId() == null) {
            return AjaxResult.warn("请输入资金账户科目");
        }

        // 将 CapitalAccountVO 转换为 CapitalAccount
        CapitalAccount capitalAccount = new CapitalAccount();
        BeanUtils.copyBeanProp(capitalAccount, capitalAccountVO);

        try {
            // 执行更新操作
            int updatedRows = capitalAccountMapper.CapitalAccountUpdate(capitalAccount);

            // 记录日志
            log.info("更新资金账户，账户编码: {}, 更新结果: {}", capitalAccountVO.getAccountCoding(), updatedRows > 0 ? "成功" : "失败");

            // 检查更新结果
            if (updatedRows == 0) {
                return AjaxResult.error("修改失败，未找到对应的记录");
            }

            return AjaxResult.success("修改成功");
        } catch (Exception e) {
            // 记录异常日志
            log.error("更新资金账户时发生异常，账户编码: {}", capitalAccountVO.getAccountCoding(), e);
            return AjaxResult.error("修改失败，系统异常：" + e.getMessage());
        }
    }

    /**
     * 批量添加资金账户
     * @param capitalAccountList 资金账户视图对象列表
     * @return AjaxResult 批量添加结果
     */
    @Override
    public AjaxResult CapitalAccountAddBatch(List<CapitalAccount> capitalAccountList) {
        if (capitalAccountList == null || capitalAccountList.isEmpty()) {
            return AjaxResult.warn("批量添加列表为空");
        }


        // 执行批量插入操作
        int insertedRows = capitalAccountMapper.CapitalAccountAddBatch(capitalAccountList);

        // 记录日志
        log.info("批量添加资金账户，共尝试插入 {} 条记录，实际插入 {} 条记录", capitalAccountList.size(), insertedRows);

        // 检查插入结果
        if (insertedRows == capitalAccountList.size()) {
            return AjaxResult.success("批量添加成功");
        } else {
            return AjaxResult.error("批量添加部分成功，实际插入 " + insertedRows + " 条记录");
        }
    }

    /**
     * 获取资金账户编号
     * @param accountSort 账户类型
     * @return AjaxResult 编号结果
     */
    @Override
    public AjaxResult number(int accountSort) {
        try {
            // 获取编号
            String number = this.getNumber(accountSort);

            // 返回查询结果
            return AjaxResult.success("查询成功", number);
        } catch (Exception e) {
            // 记录异常日志
            log.error("查询资金账户数量时发生异常", e);
            return AjaxResult.error("编号显示失败，系统异常：" + e.getMessage());
        }
    }

    /**
     * 导入用户资金账户
     * @param list 资金账户列表
     * @return AjaxResult 导入结果
     */
    @Override
    public AjaxResult importUser(List<CapitalAccount> list) {
        ArrayList<String> coding = new ArrayList<String>();
        // 使用 Stream 循环插入数据
        list.stream()
                .forEach(capitalAccount -> {
                    capitalAccount.setAccountCoding(this.getNumber(capitalAccount.getAccountSort()));
                    capitalAccount.setCodingState(1);
                    int i = capitalAccountMapper.CapitalAccountAdd(capitalAccount);
                    if (i < 0) {
                        coding.add(capitalAccount.getAccountCoding());
                    }
                });
        if (coding.size() > 0) {
            return AjaxResult.error("批量添加失败，失败数据编码：" + coding);
        }
        return AjaxResult.success("批量添加成功");
    }

    /**
     * 获取资金账户编号
     * @param accountSort 账户类型
     * @return String 编号
     */
    public String getNumber(int accountSort) {
        // 执行查询操作
        Long number = capitalAccountMapper.number(accountSort);
        // 记录日志
        log.info("查询资金账户数量，查询结果: {} 条记录", number);
        String coding;
        if (number < 10) {
            coding = "CA00" + number;
        } else if (number < 100) {
            coding = "CA0" + number;
        } else {
            coding = "CA" + number;
        }
        return coding;
    }
}
